In current generation of network devices, the software architecture is a tightly coupled monolithic having the following functionalities:                Input and Output Processing module        Database/persistent store        Algorithm/processing logic operating on data        
The components can be arranged in a pipeline such that a module's output (e.g., A) will be an input for others (e.g., B). In other words, B will start operating/functioning only when the Module A is done. This works perfectly in a small scale environment. But, in case of scaled scenario, this kind of pipelining may become a bottleneck for the entire system. Few of the challenges of monolithic systems are:                1. Limited programmability/extensibility: A small change made in one part of module, requires entire system to be rebuilt and deployed.        2. Inability to scale-out: Scaling of the system requires scaling of each individual module in effect a scale up.        3. Lack of modularity: Tight coupling between modules enables speed of processing but limits separation and reusability.        4. Resilience challenges: Since there is a lot of interdependency between modules, resilience of a module can depend on other modules and is non-deterministic.        5. De-featuring: It is difficult to impossible to remove features to build a solution with a smaller set of modules than the monolith. Once a feature is developed and compiled into the monolithic base it almost can never be removed without major development effort.        6. Plug and play: It is hard to plug and play any third party code unless there is a deep understanding of existing code have access to full code base.        
What is needed in the art are methods and systems that would overcome the limitations of existing monolithic systems for network devices.